import { Controller, Post, Get, Body, Query, Inject } from '@midwayjs/core';
import { LakalaMerchantService } from '../../service/lakala-merchant';
import { LakalaConfig } from '../../config/lakala';
import { LakalaUtils } from '../../utils/lakala';

/**
 * 拉卡拉商户进件管理端控制器
 */
@Controller('/admin/lakala/merchant')
export class AdminLakalaMerchantController {
  @Inject()
  lakalaMerchantService: LakalaMerchantService;

  private readonly utils = new LakalaUtils();

  /**
   * 获取访问令牌
   */
  @Post('/token')
  async getAccessToken(@Body() body: { appId: string; appSecret: string }) {
    try {
      const { appId, appSecret } = body;
      
      if (!appId || !appSecret) {
        return {
          success: false,
          message: '应用ID和应用密钥不能为空'
        };
      }
      
      const result = await this.lakalaMerchantService.getAccessToken(appId, appSecret);
      
      return {
        success: result.success,
        message: result.success ? '获取token成功' : result.error,
        data: result.data || null,
        code: result.code || null
      };
    } catch (error) {
      this.utils.logError('获取token失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试'
      };
    }
  }

  /**
   * 商户进件申请
   */
  @Post('/apply')
  async applyMerchant(@Body() body: any) {
    try {
      const { merchantData, accessToken } = body;
      
      if (!merchantData || !accessToken) {
        return {
          success: false,
          message: '商户信息和访问令牌不能为空'
        };
      }
      
      // 参数验证
      const validationErrors = this.validateMerchantData(merchantData);
      if (validationErrors.length > 0) {
        return {
          success: false,
          message: '参数验证失败',
          errors: validationErrors
        };
      }
      
      const result = await this.lakalaMerchantService.applyMerchant(merchantData, accessToken);
      
      return {
        success: result.success,
        message: result.success ? '商户进件申请提交成功' : result.error,
        data: result.data || null,
        code: result.code || null
      };
    } catch (error) {
      this.utils.logError('商户进件申请失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试'
      };
    }
  }

  /**
   * 查询商户审核状态
   */
  @Get('/status')
  async queryMerchantStatus(@Query() query: { merchantNo: string; accessToken: string }) {
    try {
      const { merchantNo, accessToken } = query;
      
      if (!merchantNo || !accessToken) {
        return {
          success: false,
          message: '商户号和访问令牌不能为空'
        };
      }
      
      const result = await this.lakalaMerchantService.queryMerchantStatus(merchantNo, accessToken);
      
      return {
        success: result.success,
        message: result.success ? '查询成功' : result.error,
        data: result.data || null,
        code: result.code || null
      };
    } catch (error) {
      this.utils.logError('查询商户状态失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试'
      };
    }
  }

  /**
   * 合同申请
   */
  // @Post('/contract/apply')
  // async applyContract(@Body() body: any) {
  //   try {
  //     const { contractData, accessToken } = body;
      
  //     if (!contractData || !accessToken) {
  //       return {
  //         success: false,
  //         message: '合同信息和访问令牌不能为空'
  //       };
  //     }
      
  //     // 参数验证
  //     const validationErrors = this.validateContractData(contractData);
  //     if (validationErrors.length > 0) {
  //       return {
  //         success: false,
  //         message: '参数验证失败',
  //         errors: validationErrors
  //       };
  //     }
      
  //     const result = await this.lakalaMerchantService.applyContract(contractData);
      
  //     return {
  //       success: result.success,
  //       message: result.success ? '合同申请提交成功' : result.error,
        
  //     };
  //   } catch (error) {
  //     this.utils.logError('合同申请失败', error);
  //     return {
  //       success: false,
  //       message: '系统错误，请稍后重试'
  //     };
  //   }
  // }

  /**
   * 查询合同状态
   */
  @Get('/contract/status')
  async queryContractStatus(@Query() query: { contractNo: string; accessToken: string }) {
    try {
      const { contractNo, accessToken } = query;
      
      if (!contractNo || !accessToken) {
        return {
          success: false,
          message: '合同号和访问令牌不能为空'
        };
      }
      
      const result = await this.lakalaMerchantService.queryContractStatus(contractNo, accessToken);
      
      return {
        success: result.success,
        message: result.success ? '查询成功' : result.error,
        data: result.data || null,
        code: result.code || null
      };
    } catch (error) {
      this.utils.logError('查询合同状态失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试'
      };
    }
  }

  /**
   * 文件上传
   */
  @Post('/file/upload')
  async uploadFile(@Body() body: { file: any; fileType: string; accessToken: string }) {
    try {
      const { file, fileType, accessToken } = body;
      
      if (!file || !fileType || !accessToken) {
        return {
          success: false,
          message: '文件、文件类型和访问令牌不能为空'
        };
      }
      
      // 验证文件类型
      const fileConfig = LakalaConfig.getFileConfig();
      if (!this.utils.validateFileType(file.name, fileConfig.allowedTypes)) {
        return {
          success: false,
          message: `不支持的文件类型，支持的类型：${fileConfig.allowedTypes.join(', ')}`
        };
      }
      
      // 验证文件大小
      if (file.size > fileConfig.maxSize) {
        return {
          success: false,
          message: `文件大小超过限制，最大支持${this.utils.formatFileSize(fileConfig.maxSize)}`
        };
      }
      
      const result = await this.lakalaMerchantService.uploadFile(file, fileType, accessToken);
      
      return {
        success: result.success,
        message: result.success ? '文件上传成功' : result.error,
        data: result.data || null,
        code: result.code || null
      };
    } catch (error) {
      this.utils.logError('文件上传失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试'
      };
    }
  }

  /**
   * 文件下载
   */
  @Get('/file/download')
  async downloadFile(@Query() query: { fileId: string; accessToken: string }) {
    try {
      const { fileId, accessToken } = query;
      
      if (!fileId || !accessToken) {
        return {
          success: false,
          message: '文件ID和访问令牌不能为空'
        };
      }
      
      const result = await this.lakalaMerchantService.downloadFile(fileId, accessToken);
      
      if (result.success) {
        return result.data; // 直接返回文件流
      } else {
        return {
          success: false,
          message: result.error
        };
      }
    } catch (error) {
      this.utils.logError('文件下载失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试'
      };
    }
  }

  /**
   * 生成商户号
   */
  @Get('/generate/merchant-no')
  async generateMerchantNo() {
    try {
      const merchantNo = this.utils.generateMerchantNo();
      
      return {
        success: true,
        message: '生成成功',
        data: { merchantNo }
      };
    } catch (error) {
      this.utils.logError('生成商户号失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试'
      };
    }
  }

  /**
   * 生成合同号
   */
  @Get('/generate/contract-no')
  async generateContractNo() {
    try {
      const contractNo = this.utils.generateContractNo();
      
      return {
        success: true,
        message: '生成成功',
        data: { contractNo }
      };
    } catch (error) {
      this.utils.logError('生成合同号失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试'
      };
    }
  }

  /**
   * 获取配置信息
   */
  @Get('/config')
  async getConfig() {
    try {
      return {
        success: true,
        message: '获取成功',
        data: {
          merchantTypes: LakalaConfig.MERCHANT_TYPES,
          contractTypes: LakalaConfig.CONTRACT_TYPES,
          signTypes: LakalaConfig.SIGN_TYPES,
          fileTypes: LakalaConfig.FILE_TYPES,
          fileConfig: LakalaConfig.getFileConfig()
        }
      };
    } catch (error) {
      this.utils.logError('获取配置失败', error);
      return {
        success: false,
        message: '系统错误，请稍后重试'
      };
    }
  }

  /**
   * 验证商户数据
   */
  private validateMerchantData(data: any): string[] {
    const errors: string[] = [];
    
    if (!data.merchantNo) errors.push('商户号不能为空');
    if (!data.merchantName) errors.push('商户名称不能为空');
    if (!data.merchantType) errors.push('商户类型不能为空');
    if (!data.businessLicense) errors.push('营业执照号不能为空');
    if (!data.legalPerson) errors.push('法人姓名不能为空');
    if (!data.contactPhone) errors.push('联系电话不能为空');
    if (!data.contactEmail) errors.push('联系邮箱不能为空');
    if (!data.bankAccount) errors.push('银行账户不能为空');
    if (!data.bankName) errors.push('开户银行不能为空');
    
    // 格式验证
    if (data.contactPhone && !this.utils.validatePhone(data.contactPhone)) {
      errors.push('联系电话格式不正确');
    }
    
    if (data.contactEmail && !this.utils.validateEmail(data.contactEmail)) {
      errors.push('联系邮箱格式不正确');
    }
    
    if (data.businessLicense && !this.utils.validateBusinessLicense(data.businessLicense)) {
      errors.push('营业执照号格式不正确');
    }
    
    if (data.bankAccount && !this.utils.validateBankCard(data.bankAccount)) {
      errors.push('银行账户格式不正确');
    }
    
    return errors;
  }

  /**
   * 验证合同数据
   */
  private validateContractData(data: any): string[] {
    const errors: string[] = [];
    
    if (!data.merchantNo) errors.push('商户号不能为空');
    if (!data.contractType) errors.push('合同类型不能为空');
    if (!data.contractTemplate) errors.push('合同模板不能为空');
    if (!data.signType) errors.push('签署类型不能为空');
    if (!data.signerName) errors.push('签署人姓名不能为空');
    if (!data.signerPhone) errors.push('签署人电话不能为空');
    if (!data.signerIdCard) errors.push('签署人身份证号不能为空');
    
    // 格式验证
    if (data.signerPhone && !this.utils.validatePhone(data.signerPhone)) {
      errors.push('签署人电话格式不正确');
    }
    
    if (data.signerIdCard && !this.utils.validateIdCard(data.signerIdCard)) {
      errors.push('签署人身份证号格式不正确');
    }
    
    return errors;
  }
}